﻿using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using DynamicAuditor.DTOs;

namespace DynamicAuditor.DALAuditor
{


    /// <summary>
    /// Fecha: 01-Octubre-2010
    /// Autor:Kenneth Bogantes F
    /// Descripcion: En esta clase se va a manejar todas las operaciones correspondientes a DOMINIOS tales como: Insercion, Actualizacion, Eliminacion
    /// y todo lo relaciona con DOMINIOS.
    /// </summary>
  public  class clsDominioMg
    {

        //Declaracion de la varaiable tipo datacontext que vamos a utilizar en toda la clase.
        DynamicAuditorDataContext bd = new DynamicAuditorDataContext();


        public clsDominioMg() { 
        
        
        }





        #region Funciones_Basicas_Mantenimientos

//--------------------------------------------------------------------------------------------------------------------------

        public int InsertDominioCobit(DTOs.dtoDominios dominios)
        {
            //Se retorna un 1 si el proceso se realizo correctamente de lo contrario se retorna un 0

            int x = 0;
            DOMINIO dom = new DOMINIO();

            try
            {

                dom.idVersionCobit = dominios.Versioncobit.idVersionCobit;
                dom.NombreDominio = dominios.Nombredominio;
                dom.Descripcion = dominios.Descripcion;
                dom.Activo = dominios.Activo;
                //Se procede a insertar la informacion del dominio cobit
                bd.DOMINIOs.InsertOnSubmit(dom);
                bd.SubmitChanges();
                x = 1;
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo insertar el dominio cobit. " + ex.Message);

            }
            return x;
        }



        //--------------------------------------------------------------------------------------------------------------------------


        public int UpdateDominioCobit(DTOs.dtoDominios dominio)
        {
            //Se retorna un 1 si el proceso se realizo correctamente de lo contrario se retorna un 0

            int x = 0;


            try
            {

                DOMINIO domi = bd.DOMINIOs.Single(p => p.idDominio == dominio.Iddominio);
                domi.idDominio = dominio.Iddominio;
                domi.idVersionCobit = dominio.Versioncobit.idVersionCobit;
                domi.NombreDominio = dominio.Nombredominio;
                domi.Activo = dominio.Activo;
                domi.Descripcion = dominio.Descripcion;
                bd.SubmitChanges();
                x = 1;
            }
            catch (Exception ex)
            {
                throw new Exception("Ocurrio un error actualizando los dominios cobit . " + ex.Message);
            }
            return x;
        }

        
        
        //--------------------------------------------------------------------------------------------------------------------------
        
        
        
        public int DeleteDominioCobit(DTOs.dtoDominios dominio)
        {
            //Se retorna un 1 si el proceso se realizo correctamente de lo contrario se retorna un 0

            int x = 0;

            try
            {

                var dom = bd.DOMINIOs.Single(p => p.idDominio  == dominio.Iddominio);

                bd.DOMINIOs.DeleteOnSubmit(dom);
                bd.SubmitChanges();
                x = 1;
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo borrar el dominio " + ex.Message);
                
            }

            return x;

        }


        //--------------------------------------------------------------------------------------------------------------------------



        public DTOs.dtoDominios ObtenerDominioCobitporId(int iddominio)
        {
            DTOs.dtoDominios domi = new DynamicAuditor.DTOs.dtoDominios();

            try
            {
                DOMINIO dato = bd.DOMINIOs.Single(p => p.idDominio == iddominio);


               
                domi.Iddominio = int.Parse(dato.idDominio.ToString());
                domi.Nombredominio = dato.NombreDominio;
                domi.Versioncobit = new DynamicAuditor.DALAuditor.clsVersionCobitMg().ObtenerVersionPorId(int.Parse ( dato.idVersionCobit.ToString ()));
                domi.Descripcion = dato.Descripcion;
                domi.Activo = bool.Parse(dato.Activo.ToString());


            }
            catch (Exception ex)
            {
                domi = null;
                throw new Exception("Ocurrio un error obteniendo los datos. " + ex.Message);
            }

            return domi;
        }


        //--------------------------------------------------------------------------------------------------------------------------



        public List<DTOs.dtoDominios> ObtenerDominiosCobit(int idversion)
        {
            int i = 0;
            List<DTOs.dtoDominios> listaDominios = new List<DTOs.dtoDominios>();
            ArrayList arregloversion = new ArrayList();

            try
            {
                var domins = (from p in bd.DOMINIOs
                              from d in bd.VERSION_COBITs
                              where p.idVersionCobit == d.idVersionCobit && p.idVersionCobit ==idversion
                              orderby p.Descripcion
                              select p

                           ).ToList();

                foreach (DOMINIO registro in domins)
                {
                    listaDominios.Add(new dtoDominios());
                    listaDominios[i].Iddominio = registro.idDominio;
                    listaDominios[i].Nombredominio = registro.NombreDominio;
                    //listaDominios[i].Versioncobit = new DynamicAuditor.DALAuditor.clsVersionCobitMg().ObtenerVersionporId(int.Parse(registro.idVersionCobit.ToString())); 
                    
                    listaDominios[i].Versioncobit = ToVersionCobit(registro.VERSION_COBIT);

                    //listaDominios[i].Versioncobit = registro.VERSION_COBIT;
                    listaDominios[i].Descripcion = registro.Descripcion ;

                    listaDominios[i].Activo = bool.Parse(registro.Activo.ToString());
                    i++;
                }

            }
            catch (Exception ex)
            {
                throw new Exception("Ocurrio un error obteniendo los datos. " + ex.Message);
            }


            return listaDominios;
        }


        //--------------------------------------------------------------------------------------------------------------------------


        public List<DTOs.dtoDominios> ObtenerDominiosCobitActivos(int idversion)
        {
            int i = 0;
            List<DTOs.dtoDominios> listaDominios = new List<DTOs.dtoDominios>();
            ArrayList arregloversion = new ArrayList();

            try
            {
                var domins = (from p in bd.DOMINIOs
                              from d in bd.VERSION_COBITs
                              where p.idVersionCobit == d.idVersionCobit && p.idVersionCobit == idversion
                              && p.Activo ==true 
                              orderby p.Descripcion
                              select p

                           ).ToList();

                foreach (DOMINIO registro in domins)
                {
                    listaDominios.Add(new dtoDominios());
                    listaDominios[i].Iddominio = registro.idDominio;
                    listaDominios[i].Nombredominio = registro.NombreDominio;
                    //listaDominios[i].Versioncobit = new DynamicAuditor.DALAuditor.clsVersionCobitMg().ObtenerVersionporId(int.Parse(registro.idVersionCobit.ToString())); 

                    listaDominios[i].Versioncobit = ToVersionCobit(registro.VERSION_COBIT);

                    //listaDominios[i].Versioncobit = registro.VERSION_COBIT;
                    listaDominios[i].Descripcion = registro.Descripcion;

                    listaDominios[i].Activo = bool.Parse(registro.Activo.ToString());
                    i++;
                }

            }
            catch (Exception ex)
            {
                throw new Exception("Ocurrio un error obteniendo los datos. " + ex.Message);
            }


            return listaDominios;
        }


        public dtoVersionCobit ToVersionCobit(VERSION_COBIT VerSionCobit)
        {
           
           dtoVersionCobit version = new dtoVersionCobit();

           version.idVersionCobit = VerSionCobit.idVersionCobit;
           version.Descripcion = VerSionCobit.Descripcion;
           version.Version = VerSionCobit.Version;
           version.Activa = Convert.ToBoolean(VerSionCobit.Activa);         

           return version;


        }



        #endregion




    }
}
